// This file was generated by Rcpp::compileAttributes
// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393

#ifndef __eliot_RcppExports_h__
#define __eliot_RcppExports_h__

#include <RcppArmadillo.h>
#include <Rcpp.h>

namespace eliot {

    using namespace Rcpp;

    namespace {
        void validateSignature(const char* sig) {
            Rcpp::Function require = Rcpp::Environment::base_env()["require"];
            require("eliot", Rcpp::Named("quietly") = true);
            typedef int(*Ptr_validate)(const char*);
            static Ptr_validate p_validate = (Ptr_validate)
                R_GetCCallable("eliot", "eliot_RcppExport_validate");
            if (!p_validate(sig)) {
                throw Rcpp::function_not_exported(
                    "C++ function with signature '" + std::string(sig) + "' not found in eliot");
            }
        }
    }

    inline int rcat(Rcpp::NumericVector pvec) {
        typedef SEXP(*Ptr_rcat)(SEXP);
        static Ptr_rcat p_rcat = NULL;
        if (p_rcat == NULL) {
            validateSignature("int(*rcat)(Rcpp::NumericVector)");
            p_rcat = (Ptr_rcat)R_GetCCallable("eliot", "eliot_rcat");
        }
        RObject __result;
        {
            RNGScope __rngScope;
            __result = p_rcat(Rcpp::wrap(pvec));
        }
        if (__result.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (__result.inherits("try-error"))
            throw Rcpp::exception(as<std::string>(__result).c_str());
        return Rcpp::as<int >(__result);
    }

    inline double rutnorm(double mean, double sd, double ub) {
        typedef SEXP(*Ptr_rutnorm)(SEXP,SEXP,SEXP);
        static Ptr_rutnorm p_rutnorm = NULL;
        if (p_rutnorm == NULL) {
            validateSignature("double(*rutnorm)(double,double,double)");
            p_rutnorm = (Ptr_rutnorm)R_GetCCallable("eliot", "eliot_rutnorm");
        }
        RObject __result;
        {
            RNGScope __rngScope;
            __result = p_rutnorm(Rcpp::wrap(mean), Rcpp::wrap(sd), Rcpp::wrap(ub));
        }
        if (__result.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (__result.inherits("try-error"))
            throw Rcpp::exception(as<std::string>(__result).c_str());
        return Rcpp::as<double >(__result);
    }

    inline double rltnorm(double mean, double sd, double lb) {
        typedef SEXP(*Ptr_rltnorm)(SEXP,SEXP,SEXP);
        static Ptr_rltnorm p_rltnorm = NULL;
        if (p_rltnorm == NULL) {
            validateSignature("double(*rltnorm)(double,double,double)");
            p_rltnorm = (Ptr_rltnorm)R_GetCCallable("eliot", "eliot_rltnorm");
        }
        RObject __result;
        {
            RNGScope __rngScope;
            __result = p_rltnorm(Rcpp::wrap(mean), Rcpp::wrap(sd), Rcpp::wrap(lb));
        }
        if (__result.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (__result.inherits("try-error"))
            throw Rcpp::exception(as<std::string>(__result).c_str());
        return Rcpp::as<double >(__result);
    }

    inline double rdtnorm(double mean, double sd, double lb, double ub) {
        typedef SEXP(*Ptr_rdtnorm)(SEXP,SEXP,SEXP,SEXP);
        static Ptr_rdtnorm p_rdtnorm = NULL;
        if (p_rdtnorm == NULL) {
            validateSignature("double(*rdtnorm)(double,double,double,double)");
            p_rdtnorm = (Ptr_rdtnorm)R_GetCCallable("eliot", "eliot_rdtnorm");
        }
        RObject __result;
        {
            RNGScope __rngScope;
            __result = p_rdtnorm(Rcpp::wrap(mean), Rcpp::wrap(sd), Rcpp::wrap(lb), Rcpp::wrap(ub));
        }
        if (__result.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (__result.inherits("try-error"))
            throw Rcpp::exception(as<std::string>(__result).c_str());
        return Rcpp::as<double >(__result);
    }

}

#endif // __eliot_RcppExports_h__
